package com.hunter;

import java.sql.Array;
import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

// 动态数组
public class DongTaiShuZu implements Iterable<Integer> {
    private int size = 0; // 逻辑大小
    private int capacity = 8; // 容器
    private int[] array = new int[capacity];

    /*
    1. 添加方法1:向最后位置 [size] 添加元素
    Params:element - 待添加元素
     */
    public void addLast(int element) {
        checkAndGrow();
        array[size] = element;
        size++;
    }

    /*
    2.添加方法2:向 [0...size] 位置添加元素
    Params:index - 索引位置
           element - 待添加元素
     */
    public void add(int index, int element) {
        // 容量（capacity）检查和扩容
        checkAndGrow();
        // 添加逻辑
        if (index >= 0 && index < size) {
            // 向后挪动，空出待插入位置
            System.arraycopy(array, index, // 从 array数组的 index位置 开始拷贝，
                    array, index + 1, // 将元素拷贝到array数组的 index+1位置，
                    size - index); // 拷贝 size-index个元素。
        } else {
            System.out.println("无效index，请重新输入！");
        }
        array[index] = element; // 原先 index位置 空出来了，把新值element 加入
        size++;
    }

    // 容量（capacity）检查和扩容
    private void checkAndGrow() {
        // 容量检查
        // 当数组为空时，创建一个具有初始容量的数组
        if (size == 0) {
            // 创建一个具有初始容量的数组
            array = new int[capacity];
            // 当数组已满时（即元素数量等于当前容量），进行扩容
        } else if (size == capacity) {
            // 计算新的容量，当前容量加上其一半
            capacity += capacity >> 1;
            // 创建一个新数组，其容量为新的容量
            int[] newArr = new int[capacity];
            // 当原数组中的所有元素复制到新数组中
            System.arraycopy(array, 0,
                    newArr, 0, size);
            // 将引用从旧数组指向新数组
            array = newArr;
        }
    }

    /*
    3. 查询元素
    Params:index - 索引位置，在[0...size]区间内
    Returns:该索引位置的元素
     */
    public int get(int index) {
        return array[index];
    }

    /*
    4. 循环方法1
    Params:consumer - 遍历要执行的操作，入参：每个元素
     */
    public void foreach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
//            System.out.println(array[i]);
            consumer.accept(array[i]);
        }
    }

    /*
    5.循环方法2
    迭代器遍历
     */
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() { // 有没有下一个元素
                return i < size;
            }

            @Override
            public Integer next() { // 返回当前元素，并移动到下一个元素
                return array[i++];
            }
        };
    }

    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));
    }

    /*
    6.删除方法
     */
    public int remove(int index) {
        int removed = array[index];
        if (index < size - 1) {
            System.arraycopy(array, index + 1,
                    array, index, size - index - 1);
        }
        size--;
        return removed;
    }

}
